package com.muyan.sys.webscoket.config;

import com.muyan.sys.common.core.redis.RedisCache;
import com.muyan.sys.common.utils.ip.IpUtils;
import com.muyan.sys.webscoket.constant.ChatCacheConstants;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.UUID;

@Configuration
public class RabbitMQQueConfig {


    @Autowired
    private RedisCache redisCache;

    /**
     * 私聊消息交换机（Fanout类型）
     */
    @Bean
    public FanoutExchange chatExchange() {
        return new FanoutExchange(ChatCacheConstants.MQ_PRIVATE_EXCHANGE);
    }

    /**
     * 群聊消息交换机（Fanout类型）
     */
    @Bean
    public FanoutExchange groupChatExchange() {
        return new FanoutExchange(ChatCacheConstants.MQ_GROUP_CHAT_EXCHANGE);
    }


    /**
     * 群组交换机（Fanout类型）
     */
    @Bean
    public FanoutExchange groupExchange() {
        return new FanoutExchange(ChatCacheConstants.MQ_GROUP_WS_EXCHANGE);
    }


    /**
     * 为每个实例创建私聊消息队列
     */
    @Bean
    public Queue chatQueue() {
        // 使用随机队列名，确保每个实例都有唯一的队列

        // 是否持久化
        boolean durable = false;
        // 仅创建者可以使用的私有队列，断开后自动删除
        boolean exclusive = false;
        // 当所有消费客户端连接断开后，是否自动删除队列
        boolean autoDelete = false;
        String key=ChatCacheConstants.QUE_PRIVATE+ChatCacheConstants.QUE_IP+IpUtils.getHostIp();
        String que_name= redisCache.getCacheObject(key);
        if(que_name==null){
                que_name= UUID.randomUUID().toString();
              redisCache.setCacheObject(key,que_name);
        }


        return new Queue(que_name, durable, exclusive, autoDelete);

        //   return new AnonymousQueue();
    }

    /**
     * 为每个实例创建群聊消息队列
     */
    @Bean
    public Queue groupChatQueue() {
        // 是否持久化
        boolean durable = false;
        // 仅创建者可以使用的私有队列，断开后自动删除
        boolean exclusive = false;
        // 当所有消费客户端连接断开后，是否自动删除队列
        boolean autoDelete = false;
        String key=ChatCacheConstants.QUE_GROUP_CHAT+ChatCacheConstants.QUE_IP+IpUtils.getHostIp();
        String que_name= redisCache.getCacheObject(key);
        if(que_name==null){
            que_name= UUID.randomUUID().toString();
            redisCache.setCacheObject(key,que_name);
        }


        return new Queue(que_name, durable, exclusive, autoDelete);
        // 使用随机队列名，确保每个实例都有唯一的队列
     //   return new AnonymousQueue();
    }
    /**
     * 为每个实例创建群组队列
     */
    @Bean
    public Queue groupQueue() {
        // 是否持久化
        boolean durable = false;
        // 仅创建者可以使用的私有队列，断开后自动删除
        boolean exclusive = false;
        // 当所有消费客户端连接断开后，是否自动删除队列
        boolean autoDelete = false;
        String key=ChatCacheConstants.QUE_GROUP+ChatCacheConstants.QUE_IP+IpUtils.getHostIp();
        String que_name= redisCache.getCacheObject(key);
        if(que_name==null){
            que_name= UUID.randomUUID().toString();
            redisCache.setCacheObject(key,que_name);
        }


        return new Queue(que_name, durable, exclusive, autoDelete);
        // 使用随机队列名，确保每个实例都有唯一的队列
        //   return new AnonymousQueue();
    }

    /**
     * 绑定私聊队列到交换机
     */
    @Bean
    public Binding chatBinding(Queue chatQueue, FanoutExchange chatExchange) {
        return BindingBuilder.bind(chatQueue).to(chatExchange);
    }

    /**
     * 绑定群聊队列到交换机
     */
    @Bean
    public Binding groupChatBinding(Queue groupChatQueue, FanoutExchange groupChatExchange) {
        return BindingBuilder.bind(groupChatQueue).to(groupChatExchange);
    }
    /**
     * 绑定群组队列到交换机
     */
    @Bean
    public Binding groupBinding(Queue groupQueue, FanoutExchange groupExchange) {
        return BindingBuilder.bind(groupQueue).to(groupExchange);
    }

    /**
     * 配置 RabbitTemplate
     */
/*    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
        return rabbitTemplate;
    }*/
}